/**
 * 相册数据处理器
 * 处理albumData，为Flickity相册和时间轴提供数据
 */

class AlbumDataProcessor {
    constructor(albumData) {
        this.albumData = albumData;
        this.processedData = null;
        this.yearToIndexMap = new Map();
        this.indexToYearMap = new Map();
        this.init();
    }

    /**
     * 初始化数据处理
     */
    init() {
        this.processedData = this.processAlbumData();
        this.buildIndexMaps();
    }

    /**
     * 处理albumData，扁平化并添加年份信息
     * @returns {Array} 处理后的图片数组
     */
    processAlbumData() {
        const allImages = [];
        const allYears = this.getAllYears(); // 包括空年份

        allYears.forEach(year => {
            const yearImages = this.albumData[year] || [];

            if (yearImages.length === 0) {
                // 为空年份添加占位图
                allImages.push({
                    id: `placeholder-${year}`,
                    url: '/templates/pc/images/case_holder.png',
                    title: '暂无案例',
                    year: year,
                    yearIndex: 0,
                    isFirstOfYear: true,
                    isPlaceholder: true, // 标记为占位图
                    globalIndex: allImages.length,
                    cssClass: `year-${year} placeholder-image`
                });
            } else {
                yearImages.forEach((image, index) => {
                    allImages.push({
                        ...image,
                        year: year,
                        yearIndex: index, // 在该年份中的索引
                        isFirstOfYear: index === 0, // 是否为该年份的第一张
                        isPlaceholder: false, // 不是占位图
                        globalIndex: allImages.length, // 全局索引
                        cssClass: `slide-year-${year}` // CSS修饰符类名，不包含年份选择器
                    });
                });
            }
        });

        return allImages;
    }

    /**
     * 获取有效年份（有图片的年份），按升序排列
     * @returns {Array} 年份数组
     */
    getValidYears() {
        return Object.keys(this.albumData)
            .filter(year => this.albumData[year] && this.albumData[year].length > 0)
            .sort((a, b) => parseInt(a) - parseInt(b));
    }

    /**
     * 获取所有年份（包括空的），按升序排列
     * @returns {Array} 年份数组
     */
    getAllYears() {
        return Object.keys(this.albumData)
            .sort((a, b) => parseInt(a) - parseInt(b));
    }

    /**
     * 建立年份与索引的映射关系
     */
    buildIndexMaps() {
        const years = this.getAllYears(); // 使用所有年份，包括空的
        let currentIndex = 0;

        years.forEach(year => {
            // 记录每个年份第一张图片的全局索引
            this.yearToIndexMap.set(year, currentIndex);

            const yearImages = this.albumData[year] || [];
            if (yearImages.length === 0) {
                // 空年份也占一个索引位置（占位图）
                this.indexToYearMap.set(currentIndex, year);
                currentIndex++;
            } else {
                yearImages.forEach(() => {
                    this.indexToYearMap.set(currentIndex, year);
                    currentIndex++;
                });
            }
        });
    }

    /**
     * 根据年份获取对应的第一张图片索引
     * @param {string} year 年份
     * @returns {number} 图片索引
     */
    getIndexByYear(year) {
        return this.yearToIndexMap.get(year) || 0;
    }

    /**
     * 根据图片索引获取对应的年份
     * @param {number} index 图片索引
     * @returns {string} 年份
     */
    getYearByIndex(index) {
        return this.indexToYearMap.get(index) || this.getValidYears()[0];
    }

    /**
     * 获取最小年份（用于初始索引）
     * @returns {string} 最小年份
     */
    getMinYear() {
        // 不再过滤“有效年份”，空年份也参与初始定位（有占位图）
        const years = this.getAllYears();
        return years.length > 0 ? years[0] : null;
    }

    /**
     * 获取最大年份
     * @returns {string} 最大年份
     */
    getMaxYear() {
        const years = this.getValidYears();
        return years.length > 0 ? years[years.length - 1] : null;
    }

    /**
     * 获取时间轴数据（最多9个年份，包括空年份）
     * @returns {Array} 时间轴年份数组
     */
    getTimelineData() {
        const years = this.getAllYears(); // 使用所有年份，包括空的

        // 如果年份数量超过9个，需要进行采样
        if (years.length <= 9) {
            return years;
        }

        // 采样策略：保留首尾，中间均匀分布
        const result = [years[0]]; // 保留第一个
        const step = (years.length - 1) / 8; // 计算步长，为中间7个位置

        for (let i = 1; i < 8; i++) {
            const index = Math.round(i * step);
            if (index < years.length - 1) {
                result.push(years[index]);
            }
        }

        result.push(years[years.length - 1]); // 保留最后一个

        // 去重并排序
        return [...new Set(result)].sort((a, b) => parseInt(a) - parseInt(b));
    }

    /**
     * 获取处理后的所有图片数据
     * @returns {Array} 图片数组
     */
    getAllImages() {
        return this.processedData;
    }

    /**
     * 获取年份统计信息
     * @returns {Object} 统计信息
     */
    getStatistics() {
        const years = this.getValidYears();
        const totalImages = this.processedData.length;
        
        return {
            totalYears: years.length,
            totalImages: totalImages,
            yearRange: years.length > 0 ? `${years[0]}-${years[years.length - 1]}` : '',
            averageImagesPerYear: years.length > 0 ? Math.round(totalImages / years.length) : 0,
            yearsWithImages: years,
            emptyYears: this.getAllYears().filter(year => !this.albumData[year] || this.albumData[year].length === 0)
        };
    }

    /**
     * 验证数据完整性
     * @returns {Object} 验证结果
     */
    validateData() {
        const errors = [];
        const warnings = [];

        // 检查是否有数据
        if (!this.albumData || Object.keys(this.albumData).length === 0) {
            errors.push('albumData为空或未定义');
        }

        // 检查是否有有效图片
        if (this.processedData.length === 0) {
            errors.push('没有找到有效的图片数据');
        }

        // 检查图片URL
        this.processedData.forEach((image, index) => {
            if (!image.url) {
                errors.push(`图片${index}缺少URL`);
            }
            if (!image.title) {
                warnings.push(`图片${index}缺少标题`);
            }
        });

        // 检查年份数据
        const years = this.getValidYears();
        if (years.length === 0) {
            errors.push('没有找到有效的年份数据');
        }

        return {
            isValid: errors.length === 0,
            errors: errors,
            warnings: warnings
        };
    }
}

// 导出类
if (typeof module !== 'undefined' && module.exports) {
    module.exports = AlbumDataProcessor;
} else {
    // 浏览器环境下，将类添加到全局作用域
    window.AlbumDataProcessor = AlbumDataProcessor;
}
